package com.own.entity.tuple;

import java.io.Serializable;

/**
 * Tuple
 *
 * @author chenxueli
 * @date 2024-01-31 08:57:00
 */
public record Tuple<T>(T value) implements Serializable {

    /**
     * 构造方法
     *
     * @param value 值
     * @param <T>   类型
     * @return 元组
     */
    public static <T> Tuple<T> of(T value) {
        return new Tuple<>(value);
    }

    /**
     * 构造方法
     *
     * @param value1  值1
     * @param value2  值2
     * @param <TYPE1> 类型1
     * @param <TYPE2> 类型2
     * @return 元组
     */
    public static <TYPE1, TYPE2> Tuple2<TYPE1, TYPE2> of(TYPE1 value1, TYPE2 value2) {
        return new Tuple2<>(value1, value2);
    }

    /**
     * 构造方法
     *
     * @param value1  值1
     * @param value2  值2
     * @param value3  值3
     * @param <TYPE1> 类型1
     * @param <TYPE2> 类型2
     * @param <TYPE3> 类型3
     * @return 元组
     */
    public static <TYPE1, TYPE2, TYPE3> Tuple3<TYPE1, TYPE2, TYPE3> of(TYPE1 value1, TYPE2 value2, TYPE3 value3) {
        return new Tuple3<>(value1, value2, value3);
    }

    /**
     * 构造方法
     *
     * @param value1  值1
     * @param value2  值2
     * @param value3  值3
     * @param value4  值4
     * @param <TYPE1> 类型1
     * @param <TYPE2> 类型2
     * @param <TYPE3> 类型3
     * @param <TYPE4> 类型4
     * @return 元组
     */
    public static <TYPE1, TYPE2, TYPE3, TYPE4> Tuple4<TYPE1, TYPE2, TYPE3, TYPE4> of(
            TYPE1 value1,
            TYPE2 value2,
            TYPE3 value3,
            TYPE4 value4
    ) {
        return new Tuple4<>(value1, value2, value3, value4);
    }

    /**
     * 构造方法
     *
     * @param value1  值1
     * @param value2  值2
     * @param value3  值3
     * @param value4  值4
     * @param value5  值5
     * @param <TYPE1> 类型1
     * @param <TYPE2> 类型2
     * @param <TYPE3> 类型3
     * @param <TYPE4> 类型4
     * @param <TYPE5> 类型5
     * @return 元组
     */
    public static <TYPE1, TYPE2, TYPE3, TYPE4, TYPE5> Tuple5<TYPE1, TYPE2, TYPE3, TYPE4, TYPE5> of(TYPE1 value1, TYPE2 value2, TYPE3 value3, TYPE4 value4, TYPE5 value5) {
        return new Tuple5<>(value1, value2, value3, value4, value5);
    }

    /**
     * 构造方法
     *
     * @param value1  值1
     * @param value2  值2
     * @param value3  值3
     * @param value4  值4
     * @param value5  值5
     * @param value6  值6
     * @param <TYPE1> 类型1
     * @param <TYPE2> 类型2
     * @param <TYPE3> 类型3
     * @param <TYPE4> 类型4
     * @param <TYPE5> 类型5
     * @param <TYPE6> 类型6
     * @return 元组
     */
    public static <TYPE1, TYPE2, TYPE3, TYPE4, TYPE5, TYPE6> Tuple6<TYPE1, TYPE2, TYPE3, TYPE4, TYPE5, TYPE6> of(TYPE1 value1, TYPE2 value2, TYPE3 value3, TYPE4 value4, TYPE5 value5, TYPE6 value6) {
        return new Tuple6<>(value1, value2, value3, value4, value5, value6);
    }

    /**
     * 构造方法
     *
     * @param value1  值1
     * @param value2  值2
     * @param value3  值3
     * @param value4  值4
     * @param value5  值5
     * @param value6  值6
     * @param value7  值7
     * @param <TYPE1> 类型1
     * @param <TYPE2> 类型2
     * @param <TYPE3> 类型3
     * @param <TYPE4> 类型4
     * @param <TYPE5> 类型5
     * @param <TYPE6> 类型6
     * @param <TYPE7> 类型7
     * @return 元组
     */
    public static <TYPE1, TYPE2, TYPE3, TYPE4, TYPE5, TYPE6, TYPE7> Tuple7<TYPE1, TYPE2, TYPE3, TYPE4, TYPE5, TYPE6, TYPE7> of(TYPE1 value1, TYPE2 value2, TYPE3 value3, TYPE4 value4, TYPE5 value5, TYPE6 value6, TYPE7 value7) {
        return new Tuple7<>(value1, value2, value3, value4, value5, value6, value7);
    }

    /**
     * 构造方法
     *
     * @param value1  值1
     * @param value2  值2
     * @param value3  值3
     * @param value4  值4
     * @param value5  值5
     * @param value6  值6
     * @param value7  值7
     * @param value8  值8
     * @param <TYPE1> 类型1
     * @param <TYPE2> 类型2
     * @param <TYPE3> 类型3
     * @param <TYPE4> 类型4
     * @param <TYPE5> 类型5
     * @param <TYPE6> 类型6
     * @param <TYPE7> 类型7
     * @param <TYPE8> 类型8
     * @return 元组
     */
    public static <TYPE1, TYPE2, TYPE3, TYPE4, TYPE5, TYPE6, TYPE7, TYPE8> Tuple8<TYPE1, TYPE2, TYPE3, TYPE4, TYPE5, TYPE6, TYPE7, TYPE8> of(TYPE1 value1, TYPE2 value2, TYPE3 value3, TYPE4 value4, TYPE5 value5, TYPE6 value6, TYPE7 value7, TYPE8 value8) {
        return new Tuple8<>(value1, value2, value3, value4, value5, value6, value7, value8);
    }

    /**
     * 构造方法
     *
     * @param value1  值1
     * @param value2  值2
     * @param value3  值3
     * @param value4  值4
     * @param value5  值5
     * @param value6  值6
     * @param value7  值7
     * @param value8  值8
     * @param value9  值9
     * @param <TYPE1> 类型1
     * @param <TYPE2> 类型2
     * @param <TYPE3> 类型3
     * @param <TYPE4> 类型4
     * @param <TYPE5> 类型5
     * @param <TYPE6> 类型6
     * @param <TYPE7> 类型7
     * @param <TYPE8> 类型8
     * @param <TYPE9> 类型9
     * @return 元组
     */
    public static <TYPE1, TYPE2, TYPE3, TYPE4, TYPE5, TYPE6, TYPE7, TYPE8, TYPE9> Tuple9<TYPE1, TYPE2, TYPE3, TYPE4, TYPE5, TYPE6, TYPE7, TYPE8, TYPE9> of(TYPE1 value1, TYPE2 value2, TYPE3 value3, TYPE4 value4, TYPE5 value5, TYPE6 value6, TYPE7 value7, TYPE8 value8, TYPE9 value9) {
        return new Tuple9<>(value1, value2, value3, value4, value5, value6, value7, value8, value9);
    }

}
